/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/


/*************************************************************************
 *\author: starlove
 *************************************************************************/
#ifndef __CC_PYTHON_IMPORT_O_PROTOCOLS_IMPL__
#define __CC_PYTHON_IMPORT_O_PROTOCOLS_IMPL__

#include "python_object_protocols.h"
#include "python_object_nodeobjects.h"

NS_CCPY_BEGIN

	PYCLASS_INIT_F(CPyRGBAProtocol, "CCRGBAProtocol", "Python CCRGBAProtocol Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyRGBAProtocol)
	PYCLASS_END_METHOD_DEF(CPyRGBAProtocol)
	PYCLASS_BEGIN_GETSET_DEF(CPyRGBAProtocol)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, Opacity)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, DisplayedOpacity)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, CascadeOpacityEnabled)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, Color)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, DisplayedColor)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, CascadeColorEnabled)
	PYCLASS_ADD_GETSET(CPyRGBAProtocol, OpacityModifyRGB)
	PYCLASS_END_GETSET_DEF(CPyRGBAProtocol)
	PYCLASS_IMP_INTERFACE(CPyRGBAProtocol);
	
	PYCLASS_GET_IMPL(CPyRGBAProtocol, Opacity)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		return Py_BuildValue("i", protocol->getOpacity());
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, Opacity)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->setOpacity((unsigned char)PyLong_AsLong(pyValue));
		return 0;
	}
	PYCLASS_GET_IMPL(CPyRGBAProtocol, DisplayedOpacity)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		return Py_BuildValue("i", protocol->getDisplayedOpacity());
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, DisplayedOpacity)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->updateDisplayedOpacity((unsigned char)PyLong_AsLong(pyValue));
		return 0;
	}
	PYCLASS_GET_IMPL(CPyRGBAProtocol, CascadeOpacityEnabled)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		Py_RETURN_BOOL(protocol->isCascadeOpacityEnabled());
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, CascadeOpacityEnabled)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->setCascadeOpacityEnabled(PyLong_AsLong(pyValue) != 0);
		return 0;
	}
	PYCLASS_GET_IMPL(CPyRGBAProtocol, Color)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		CPyColor3B *nv = CPyColor3B::create(protocol->getColor());
		return (PyObject *)nv;
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, Color)
	{
		if(!PyObject_TypeCheck(pyValue, CPyClassBase::GetTypeObject<CPyColor3B>()))
			return 0;
		CPyColor3B *nv = (CPyColor3B *)pyValue;
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->setColor(nv->getCCObject());
		return 0;
	}
	PYCLASS_GET_IMPL(CPyRGBAProtocol, DisplayedColor)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		CPyColor3B *nv = CPyColor3B::create(protocol->getDisplayedColor());
		return (PyObject *)nv;
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, DisplayedColor)
	{
		if(!PyObject_TypeCheck(pyValue, CPyClassBase::GetTypeObject<CPyColor3B>()))
			return 0;
		CPyColor3B *nv = (CPyColor3B *)pyValue;
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->updateDisplayedColor(nv->getCCObject());
		return 0;
	}
	PYCLASS_GET_IMPL(CPyRGBAProtocol, CascadeColorEnabled)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		Py_RETURN_BOOL(protocol->isCascadeColorEnabled());
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, CascadeColorEnabled)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->setCascadeColorEnabled(PyLong_AsLong(pyValue) != 0);
		return 0;
	}
	PYCLASS_GET_IMPL(CPyRGBAProtocol, OpacityModifyRGB)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		Py_RETURN_BOOL(protocol->isOpacityModifyRGB());
	}
	PYCLASS_SET_IMPL(CPyRGBAProtocol, OpacityModifyRGB)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCRGBAProtocol *protocol = dynamic_cast<CCRGBAProtocol *>(ccobj);
		if(protocol)
			protocol->setOpacityModifyRGB(PyLong_AsLong(pyValue) != 0);
		return 0;
	}
	

	PYCLASS_INIT_F(CPyBlendProtocol, "CCBlendProtocol", "Python CCBlendProtocol Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyBlendProtocol)
	PYCLASS_END_METHOD_DEF(CPyBlendProtocol)
	PYCLASS_BEGIN_GETSET_DEF(CPyBlendProtocol)
	PYCLASS_ADD_GETSET(CPyBlendProtocol, BlendFunc)
	PYCLASS_END_GETSET_DEF(CPyBlendProtocol)
	PYCLASS_IMP_INTERFACE(CPyBlendProtocol);
	
	PYCLASS_GET_IMPL(CPyBlendProtocol, BlendFunc)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCBlendProtocol *protocol = dynamic_cast<CCBlendProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		ccBlendFunc bc = protocol->getBlendFunc();
		return (PyObject *)CPyBlendFunc::create(bc);
	}
	PYCLASS_SET_IMPL(CPyBlendProtocol, BlendFunc)
	{
		if(!PyObject_TypeCheck(pyValue, CPyClassBase::GetTypeObject<CPyBlendFunc>()))
			return 0;
		CPyBlendFunc *pybc = (CPyBlendFunc *)pyValue;
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCBlendProtocol *protocol = dynamic_cast<CCBlendProtocol *>(ccobj);
		if(protocol)
			protocol->setBlendFunc(pybc->getCCObject());
		return 0;
	}

	PYCLASS_INIT_AND_BASE(CPyTextureProtocol, CPyBlendProtocol, "CCTextureProtocol", "Python CCTextureProtocol Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyTextureProtocol)
	PYCLASS_END_METHOD_DEF(CPyTextureProtocol)
	PYCLASS_BEGIN_GETSET_DEF(CPyTextureProtocol)
	PYCLASS_ADD_GETSET(CPyTextureProtocol, Texture)
	PYCLASS_END_GETSET_DEF(CPyTextureProtocol)
	PYCLASS_IMP_INTERFACE(CPyTextureProtocol);
	
	PYCLASS_GET_IMPL(CPyTextureProtocol, Texture)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCTextureProtocol *protocol = dynamic_cast<CCTextureProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		CCTexture2D *tex = protocol->getTexture();
		if(tex)
			return (PyObject *)CPyCCObject::create<CPyTexture2D>(tex);
		Py_RETURN_NONE;
	}
	PYCLASS_SET_IMPL(CPyTextureProtocol, Texture)
	{
		if(!PyObject_TypeCheck(pyValue, CPyClassBase::GetTypeObject<CPyTexture2D>()))
			return 0;
		CPyTexture2D *pytex = (CPyTexture2D *)pyValue;
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCTextureProtocol *protocol = dynamic_cast<CCTextureProtocol *>(ccobj);
		if(protocol)
			protocol->setTexture((CCTexture2D *)pytex->getCCObject());
		return 0;
	}
	

	PYCLASS_INIT_F(CPyLabelProtocol, "CCLabelProtocol", "Python CCLabelProtocol Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyLabelProtocol)
	PYCLASS_END_METHOD_DEF(CPyLabelProtocol)
	PYCLASS_BEGIN_GETSET_DEF(CPyLabelProtocol)
	PYCLASS_ADD_GETSET(CPyLabelProtocol, String)
	PYCLASS_END_GETSET_DEF(CPyLabelProtocol)
	PYCLASS_IMP_INTERFACE(CPyLabelProtocol);
	
	PYCLASS_GET_IMPL(CPyLabelProtocol, String)
	{
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCLabelProtocol *protocol = dynamic_cast<CCLabelProtocol *>(ccobj);
		if(!protocol)
			Py_RETURN_NONE;
		return Py_BuildValue("s", protocol->getString());
	}
	PYCLASS_SET_IMPL(CPyLabelProtocol, String)
	{
		CPyBlendFunc *pybc = (CPyBlendFunc *)pyValue;
		CPyCCObject *obj = (CPyCCObject *)pySelf;
		CCObject *ccobj = obj->getCCObject();
		CCLabelProtocol *protocol = dynamic_cast<CCLabelProtocol *>(ccobj);
		if(protocol)
			protocol->setString(PyString_AsString(pyValue));
		return 0;
	}
	
	PYCLASS_INIT_F(CPyTouchDelegate, "CCTouchDelegate", "Python CCTouchDelegate Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyTouchDelegate)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchBegan)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchMoved)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchEnded)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchCancelled)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchesBegan)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchesMoved)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchesEnded)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, ccTouchesCancelled)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchBegan)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchMoved)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchEnded)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchCancelled)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchesBegan)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchesMoved)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchesEnded)
    PYCLASS_ADD_METHOD(CPyTouchDelegate, _ccTouchesCancelled)
	PYCLASS_END_METHOD_DEF(CPyTouchDelegate)
	PYCLASS_BEGIN_GETSET_DEF(CPyTouchDelegate)
	PYCLASS_END_GETSET_DEF(CPyTouchDelegate)
	PYCLASS_IMP_INTERFACE(CPyTouchDelegate);
	
	PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchBegan)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchMoved)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchEnded)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchCancelled)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchesBegan)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchesMoved)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchesEnded)
	{
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, ccTouchesCancelled)
	{
		Py_RETURN_NONE;
	}

	PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchBegan)
	{
		PyObject *pytouch = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouch) )
			Py_RETURN_FALSE;
		if(!PyObject_TypeCheck(pytouch, CPyClassBase::GetTypeObject<CPyTouch>()))
			Py_RETURN_FALSE;
		CPyTouch *touch = (CPyTouch *)pytouch;
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			Py_RETURN_BOOL(delegate->ccTouchBegan(dynamic_cast<CCTouch *>(touch->getCCObject()), NULL));
		Py_RETURN_FALSE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchMoved)
	{
		PyObject *pytouch = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouch) )
			Py_RETURN_NONE;
		if(!PyObject_TypeCheck(pytouch, CPyClassBase::GetTypeObject<CPyTouch>()))
			Py_RETURN_NONE;
		CPyTouch *touch = (CPyTouch *)pytouch;
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchMoved(dynamic_cast<CCTouch *>(touch->getCCObject()), NULL);
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchEnded)
	{
		PyObject *pytouch = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouch) )
			Py_RETURN_NONE;
		if(!PyObject_TypeCheck(pytouch, CPyClassBase::GetTypeObject<CPyTouch>()))
			Py_RETURN_NONE;
		CPyTouch *touch = (CPyTouch *)pytouch;
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchEnded(dynamic_cast<CCTouch *>(touch->getCCObject()), NULL);
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchCancelled)
	{
		PyObject *pytouch = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouch) )
			Py_RETURN_NONE;
		if(!PyObject_TypeCheck(pytouch, CPyClassBase::GetTypeObject<CPyTouch>()))
			Py_RETURN_NONE;
		CPyTouch *touch = (CPyTouch *)pytouch;
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchCancelled(dynamic_cast<CCTouch *>(touch->getCCObject()), NULL);
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchesBegan)
	{
		PyObject *pytouches = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouches) )
			Py_RETURN_NONE;
		if(!PySequence_Check(pytouches))
			Py_RETURN_NONE;

		CCSet *set = CCPyDataConvert::CCSetFromPyList(pytouches);
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchesBegan(set, NULL);
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchesMoved)
	{
		PyObject *pytouches = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouches) )
			Py_RETURN_NONE;
		if(!PySequence_Check(pytouches))
			Py_RETURN_NONE;

		CCSet *set = CCPyDataConvert::CCSetFromPyList(pytouches);
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchesMoved(set, NULL);
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchesEnded)
	{
		PyObject *pytouches = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouches) )
			Py_RETURN_NONE;
		if(!PySequence_Check(pytouches))
			Py_RETURN_NONE;

		CCSet *set = CCPyDataConvert::CCSetFromPyList(pytouches);
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchesEnded(set, NULL);
		Py_RETURN_NONE;
	}
    PYCLASS_METHOD_IMPL(CPyTouchDelegate, _ccTouchesCancelled)
	{
		PyObject *pytouches = NULL;
		if( !PyArg_ParseTuple(pyArgs, "O", &pytouches) )
			Py_RETURN_NONE;
		if(!PySequence_Check(pytouches))
			Py_RETURN_NONE;

		CCSet *set = CCPyDataConvert::CCSetFromPyList(pytouches);
		CPyCCObject *pyo = (CPyCCObject *)pySelf;
		CCTouchDelegate *delegate = dynamic_cast<CCTouchDelegate *>(pyo->getCCObject());
		if(delegate)
			delegate->ccTouchesCancelled(set, NULL);
		Py_RETURN_NONE;
	}
	
	PYCLASS_INIT_F(CPyAccelerometerDelegate, "CCAccelerometerDelegate", "Python CCAccelerometerDelegate Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyAccelerometerDelegate)
    PYCLASS_ADD_METHOD(CPyAccelerometerDelegate, didAccelerate)
	PYCLASS_END_METHOD_DEF(CPyAccelerometerDelegate)
	PYCLASS_BEGIN_GETSET_DEF(CPyAccelerometerDelegate)
	PYCLASS_END_GETSET_DEF(CPyAccelerometerDelegate)
	PYCLASS_IMP_INTERFACE(CPyAccelerometerDelegate);
	
	PYCLASS_METHOD_IMPL(CPyAccelerometerDelegate, didAccelerate)
	{
		Py_RETURN_NONE;
	}

	PYCLASS_INIT_F(CPyKeypadDelegate, "CCKeypadDelegate", "Python CCKeypadDelegate Object");
	PYCLASS_BEGIN_METHOD_DEF(CPyKeypadDelegate)
    PYCLASS_ADD_METHOD(CPyKeypadDelegate, keyBackClicked)
    PYCLASS_ADD_METHOD(CPyKeypadDelegate, keyMenuClicked)
	PYCLASS_END_METHOD_DEF(CPyKeypadDelegate)
	PYCLASS_BEGIN_GETSET_DEF(CPyKeypadDelegate)
	PYCLASS_END_GETSET_DEF(CPyKeypadDelegate)
	PYCLASS_IMP_INTERFACE(CPyKeypadDelegate);
	
	PYCLASS_METHOD_IMPL(CPyKeypadDelegate, keyBackClicked)
	{
		Py_RETURN_NONE;
	}

	PYCLASS_METHOD_IMPL(CPyKeypadDelegate, keyMenuClicked)
	{
		Py_RETURN_NONE;
	}
NS_CCPY_END

#endif